Integrantes del grupo: David Rodríguez Calle, Eduard Gabriel Turtoi, Boyi Wang Chen, Antonio Ismael Cruz Tejada, Hector Triviño Landeira.
f = open("workfile", "w", encoding = "utf-8")
f.close()
Un ejemplo de código implementado en el modo "w":
f = open("test.text", "w")
f.write("Mi primer archivo escrito desde Python\n")
f.write("------------------------------------\n")
f.write("Hola, Mundo!\n")
f.close()
Sin embargo, en la práctica, se recomienda el uso de "with".
with open("workfile", encoding="utf-8") as f:
read_data = f.read()
De esta manera se cierra automáticamente el archivo evitando que se pueda perder el código.
El modo permite asignar al fichero la acción que se relizaría en él. Los principales tipos de modos son:
En cuanto a la lectura de archivos, mediante el modo asignado "r" (read), un sencillo patrón como el siguiente, nos permitirá leer nuestro archivo:
mi_nuevo_archivo = open("C:/Users/Antonio/Desktop/test.txt", "r")
#Se mantiene leyendo siempre.
while True:
#Intenta leer la siguiente líena.
linea = mi_nuevo_archivo.readline()
#Si no hay más líneas abandona el bucle.
if len(linea) == 0:
break
#Ahora procesa la líena que acabamos de leer.
print(linea, end="")
mi_nuevo_archivo.close()
Este es un archivo de prueba Hola M2
Un caso particular del modo "r" sería el de uso de listas, permite agrupar las líneas de código en una sola lista.
f = open("C:/Users/Antonio/Desktop/amigos.txt", "r")
nombres = f.readlines()
f.close()
print(nombres)
nombres.sort()
nombres_ordenados = open("C:/Users/Antonio/Desktop/amigos_ordenados.txt", "r+")
for line in nombres:
nombres_ordenados.write(line)
print(line,end="")
nombres_ordenados.close()
['Pedro\n', 'Alejandro\n', 'Boyi\n', 'Rodrigo\n', 'Manuel\n'] Alejandro Boyi Manuel Pedro Rodrigo
Otro método útil para la lectura de archivos es leer el contenido completo del archivo en una cadena, si no interesa la estructura de líneas.
Por ejemplo:
f = open("C:/Users/Antonio/Desktop/archivo_ejemplo.txt")
contenido = f.read()
f.close()
palabras = contenido.split()
for palabra in palabras:
print(palabra, end=", ")
print("Hay {0} palabras en el archivo".format(len(palabras)))
Patata, patatita, patatona, Hay 3 palabras en el archivo
"c:/temp/words.txt" o "c:\\temp\\words.txt"
archivo_de_palabras = open ( "/usr/share/dict/words" , "r" )
Las siglas CSV vienen del inglés "Command Separated Values" y significan valores separadas por comas. De esta manera un archivo CSV es cualquier archivo de texto en el que los caracteres están separados por comas, haciendo una tabla de filas y columnas. Las filas se definen por una línea adicional en el texto y las columnas por cada punto y coma (;).
Dependiendo de la región en la que estemos trabajando se utilizará una notación u otras, en países anglosajones se uitilizan las comas (,) para separar los elementos, mientras que en países europeas se utilizan los puntos y coma (;).
Una de las ventajas de los archivos .CSV es la facilidad con la que se pueden almacenar datos y el poco espacio de almacenamiento que ocupan. Normalmente se asocian este tipo de archivos con Excel, ya que es la forma más común de leer estos archivos, sin embargo excel no siempre es capaz de leer este tipo de archivos.
Los archivos .csv nos ayudan a manejar grandes cantidades de datos en un formato tipo tabla de un forma sencilla y sin que eso conlleve un sobrecosto computacional innecesario. La creación de una tabla es tan sencilla como abrir un bloc de notas vacío, escribir dos caracteres separados por una coma, los cuales funcionaran como cabeceras de las columnas, y después escribir los caracteres que se deseen debajo de las columnas que les corrsponda. Normalmente el siguiente paso es convertir ese csv a Excel.
En caso de que necesites usar un separador como parte del contenido de una celda, tendrás que usar comillas para abarcar tantos caracteres como quieras en dicha celda, así Excel lo identificará como un solo bloque y le asignará una única celda.
La parte "mala" de esto es que los archivos CSV tan solo admiten datos "en crudo", es decir, no podremos seleccionar colores ni formatos de tabla que queramos visualizar una vez lo abramos con Excel, por ejemplo. Estas propiedades son ajenas al documento y son tratadas desde el programa con el que abramos el archivo CSV.
En python tenemos incorporado el módulo CSV que implementa clases que leen y escriben datos de tablas principalmente en formato CSV. Este módulo permite a los programadores guardar mucha información en un formato que ocupa poco espacio y que funciona muy bien con Excel o poder leer datos de un archivo generado por Excel sin conocer los detalles precisos del formato CSV utilizado por Excel.
Este módulo tiene como predeterminado tres "dialectos" que son los formatos que es capaz de leer y escribir, aunque nosotros podremos crear nuestros propios formatos personalizados o importarlos. Los tres predeterminados son Excel, Excel-tab y unix, principalmente usaremos el formato excel.
Las funciones más útiles que nos proporciona este módula son las siguientes:
import csv
csv.writer : Con esta función podremos escribir en archivos CSV.
Los parametros de la función son:
csvfile: un archivo con el metodo write()
Dentro de esta funcíon tenemos los métodos: writerow() y writerows()
writerow(): Este método escribe una única línea a la vez, es útil para escribir las cabeceras de las columnas.
#Cabeceras
cabeceras = ['Nombre', "Asignatura", "Grupo", "Nota"]
#Filas del archivos CSV
filas = [["Antonio", "TAE", "M2", 5.0],
["Paula", "Matemáticas I", "M1", 4.7],
["Ana", "Física I", "M5", 9.0],
["José Luis", "Informática", "M3", 6.2]]
#Nombre del archivo CSV
filename = "notas_ordinarios.csv"
#Escritura como CSV
with open(filename, "w") as csvfile:
#creando un objeto de escritura nuevo del tipo csv
csvwriter = csv.writer(csvfile)
#escribiendo las cabeceras
csvwriter.writerow(cabeceras)
#escribiendo los datos
csvwriter.writerows(filas)
Los parámetros de la función son:
csv.DictWriter nos proporciona dos métodos para escribir en CSV:
# importing the csv module
import csv
# my data rows as dictionary objects
midiccionario =[{'Asignatura': 'TAE', 'Nota': 9.0, 'Nombre': 'Javier', 'Grupo': 'M2'},
{'Asignatura': 'Física I', 'Nota': 9.1, 'Nombre': 'Pedro', 'Grupo': 'T2'},
{'Asignatura': 'Matemáticas I', 'Nota': 9.3, 'Nombre': 'David', 'Grupo': 'T2'},
{'Asignatura': 'Informática', 'Nota': 9.5, 'Nombre': 'Magdalena', 'Grupo': 'M1'},
{'Asignatura': 'TAE', 'Nota': 7.8, 'Nombre': 'María José', 'Grupo': 'M3'},
{'Asignatura': 'Química', 'Nota': 9.1, 'Nombre': 'Héctor', 'Grupo': 'M2'}]
# field names
cabeceras = ['Nombre', 'Asignatura', 'Grupo', 'Nota']
# name of csv file
filename = "Notas_ordinarios_V2.csv"
# writing to csv file
with open(filename, 'w') as csvfile:
# creando un arhcivo csv de tipo diccionario
writer = csv.DictWriter(csvfile, fieldnames = cabeceras)
# escritura de las cabeceras
writer.writeheader()
# escritura de los datos en las filas
writer.writerows(midiccionario)
Los parametros de la función son:
Dependiendo el tipo de quoting que usemos nos devolverá los datos de una forma u otra.
Las distintos tipos de quoting que tenemos son:
with open("./notas_ordinarios.csv", newline="\r\n") as csvfile:
reader = csv.reader(csvfile, delimiter=",",)
for row in reader:
print(row)
['Nombre', 'Asignatura', 'Grupo', 'Nota'] ['Antonio', 'TAE', 'M2', '5.0'] ['Paula', 'Matemáticas I', 'M1', '4.7'] ['Ana', 'Física I', 'M5', '9.0'] ['José Luis', 'Informática', 'M3', '6.2']
Los parámetros de la función son:
with open("./Notas_ordinarios_V2.csv", newline="") as csvfile:
reader = csv.DictReader(csvfile, delimiter=",", quoting=csv.QUOTE_NONE)
for row in reader:
print(row)
print(row['Nombre'])
{'Nombre': 'Javier', 'Asignatura': 'TAE', 'Grupo': 'M2', 'Nota': '9.0'}
Javier
{'Nombre': 'Pedro', 'Asignatura': 'Física I', 'Grupo': 'T2', 'Nota': '9.1'}
Pedro
{'Nombre': 'David', 'Asignatura': 'Matemáticas I', 'Grupo': 'T2', 'Nota': '9.3'}
David
{'Nombre': 'Magdalena', 'Asignatura': 'Informática', 'Grupo': 'M1', 'Nota': '9.5'}
Magdalena
{'Nombre': 'María José', 'Asignatura': 'TAE', 'Grupo': 'M3', 'Nota': '7.8'}
María José
{'Nombre': 'Héctor', 'Asignatura': 'Química', 'Grupo': 'M2', 'Nota': '9.1'}
Héctor
Numpy: Para utilizar matrices en el cálculo de los puntos de las funciones.
Matplotlib: Para representar las funciones, haciendo uso de contornos y herramientas para representar funciones de dos variables en 3D.
Csv: Para escribir y leer archivos .csv de una forma más simple que si estos se trataran como ficheros.
import numpy as np
import matplotlib.pyplot as plt
import csv
def f_x1(x):
"""Polinomio de grado 10 que se aprozima a los valores del coeficiente de presiones de un cilindro
obtenidos experimentalmente"""
return -0.0544339494 * x ** 10 + 0.7877499216 * x ** 9 - 4.5754539125 * x ** 8 + 12.9373935548 * x ** 7 - 14.6038654707 * x ** 6 - 11.8402960283 * x ** 5 + 52.4289810264 * x ** 4 - 53.9857029054 * x ** 3 + 19.5695202645 * x ** 2 - 3.130686006 * x + 1.0861351645
def f_x2(x):
"""Distribución teórica del coeficiente de presiones en un cilindro, sin considerar los esfuerzos viscosos."""
return 1 - 4 * np.sin(x) ** 2
def f_xy(x, y):
"""Función de dos variables con senos y cosenos"""
return (np.sin(x)*np.cos(y * x)**2 + np.cos(y))/(np.pi/np.e)
En la primera línea, se abre un archivo csv, en el modo de escritura. Después llamamos a la función csv.writer para crear un objeto que nos permita editar archivos .csv de forma fácil. Tras hacer esto y crear un vector con los valores de x que se van a emplear para calcular las funciones dentro del intervalor deseado, se escribe en cada fila del archivo el valor de x y los valores de f1(x) y f2(x) que le corresponden.
with open("Datos_fx.csv", "w", newline='\r\n') as entrada1:
csvwriter = csv.writer(entrada1, dialect='excel') # Creación de un "writer"
x = np.linspace(0, np.pi, 100) # x es un vector con 100 elementos equiespaciados entre 0 y pi
cabecera = ["x", "f1(x)", "f2(x)"]
csvwriter.writerow(cabecera) # Insertar la cabecera del archivo
for i in x: # Recorrer todos los valores de x para los que se va a estudiar la función
row = [i, f_x1(i), f_x2(i)] # Disponer en una fila el valor de x, y sus correspondientes imágenes
csvwriter.writerow(row)
Partiendo del archivo csv con los datos necesarios para representar las dos funciones, se abre este en modo de lectura y se crea un objeto para leerlo con la función csv.reader. Se almacenarán en vectores los valores obtenidos en cada línea según estos se van leyendo del archivo y, después de haberlo leído por completo y cerrar el archivo. Se graficarán las dos funciones con la función plot.
with open("Datos_fx.csv", "r", newline='\r\n') as salida1:
reader = csv.reader(salida1, dialect='excel')
next(reader) # Se usa la función next() para saltar la línea del encabezado
x = np.array([]) # Se inicializan tres vectores vacíos, para alojar los valores de
fx1 = np.array([]) # x, f1 y f2 del archivo
fx2 = np.array([])
for line in reader: # Se recorren todas las líneas restantes del archivo de una en una,
# añadiendo cada elemento al vector que le corresponde
x = np.append(x, float(line[0]))
fx1 = np.append(fx1, float(line[1]))
fx2 = np.append(fx2, float(line[2]))
plt.plot(x, fx1) #Representar la primera función
plt.plot(x, fx2) #Representar la segunda función
[<matplotlib.lines.Line2D at 0x1d0d59ebaf0>]
Al igual que para escribir el archivo anterior, se siguen los pasos hasta crear un 'writer' para un nuevo archivo. Empleamos la función meshgrid sobre dos vectores x e y de longitud n (que contienen todos los valores de x e y de que va a tomar la función) para obtener matrices de n * n que permitan la aplicación directa de la función f_xy para obtener una matriz Z que contenga todos los resultados calculados. Una vez se tienen las matrices X, Y y Z, se recorren estas, escribiendo en una misma fila los valores de las tres matrices que se encuentran en la misma posición.
Al recibir dos matrices de dimensión uno y tamaños m y n, devolverá dos matrices de dimensión dos y tamaño m*n, en las cuales se ha asociado el primer vector a la dirección horizontal, y el segundo a la vertical.
with open("Datos_fxy.csv", "w", newline='\r\n') as entrada2:
csvwriter = csv.writer(entrada2, dialect='excel')
x = np.linspace(-5, 5, 500) # Se crean dos vectores con 500 valores equiespaciados entre -5 y 5
y = np.linspace(-5, 5, 500)
X, Y = np.meshgrid(x,y) # Utilizando meshgrid, se obtienden dos matrices X e Y, de 2 dimensiones
Z = f_xy(X, Y) # Z es resultado de aplicar la función f_xy a los elementos de X e Y de la misma posición
cabecera = ["x", "y", "f(x,y)"]
csvwriter.writerow(cabecera) # Escritura de un cabecero en el archivo
for i in range(np.shape(Z)[0]): # Para recorrer todas las filas de las matrices, se da como argumento a range
# el número de filas de Z (que sería el mismo para X e Y)
for j in range(np.shape(Z)[1]): # Se da el mismo caso que en la línea anterior, para recorrer
# las columnas de X, Y y Z
row = [X[i,j], Y[i,j], Z[i, j]] # Se escribe en una fila el valor de X, Y y Z correspondiente
csvwriter.writerow(row) # a una misma posición
Siguiendo los pasos realizados antes para crear un objeto de tipo 'reader', se recorren las filas del archivo una a una y se guardan ordenamente los datos en tres listas X, Y y Z. Estas listas se reducen a una sola dimensión (a diferencia de las matrices a partir de las cuales se escribió el archivo), pero si se tiene en cuenta el orden seguido al guardar los datos en el archivo (escribiendo los datos de cada fila de las matrices por completo antes de pasar a la siguiente) se pueden transformar las listas X, Y, Z actuales en matrices que sean iguales a las originales mediante el uso de la función reshape, que dividirá las listas de 2500 elementos en 500 filas de 500 elementos cada una.
with open("Datos_fxy.csv", "r", newline='\r\n') as salida2:
reader = csv.reader(salida2, dialect = 'excel')
next(reader) #Saltar línea del encabezado
X, Y, Z = [], [], [] #Se inicializan tres listas vacías, para alojar los valores de x, y, z de cada fila
for line in reader: #Recorrer todas las filas restantes del archivo
X.append(float(line[0]))
Y.append(float(line[1]))
Z.append(float(line[2]))
X = np.array(X).reshape((500,500)) # Modificar la forma del vector y convertirlo en un array de dimensión 2,
Y = np.array(Y).reshape((500,500)) # recuperando así su forma original antes de ser escrito en el archivo csv
Z = np.array(Z).reshape((500,500))
Para ofrecer una representación detallada de la función en dos dimensiones, se emplean contornos y un mapa de colores para ilustrar las zonas de la función con valores mayores y menores. Los contornos diferencian los valores positivos y negativos mediante líneas continuas (valores positivos) y de trazos (valores negativos).
contours = plt.contour(X, Y, Z, 5, # Se crean 5 niveles para mostrar las líneas de contorno de
colors='black', alpha = 0.8) # la superficie, de color negro y una transparencia de 0.8
plt.clabel(contours, inline=True, fontsize=8) # El valor de z para cada nivel se mostrará en la línea del
# contorno, y el tamaño de las letras será 8
plt.imshow(Z, extent=[-5, 5, -5, 5], origin='lower', # Se muestra el mapa de colores de la función, dándole también
cmap='jet', alpha=0.8) # una transparencia de 0.8
plt.colorbar() # Añadir una barra a la izquierda que sirva de leyenda
# para ayudar a comprender el mapa de colores
<matplotlib.colorbar.Colorbar at 0x1d0d5fc8f70>
Con el objetivo de facilitar la visualización de la función, esta también se ha representado en un espacio de 3 dimensiones, utilizando el mismo mapa de colores que en la sección anterior.
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='jet')
plt.show()